home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / samples / newdemo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  10.5 KB  |  407 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. /*
  21.  *  newdemo.c    -    A demo program using PDCurses. The program illustrate
  22.  *               the use of colours for text output.
  23.  */
  24.  
  25. #include <stdio.h>
  26. #include <signal.h>
  27. #include <time.h>
  28. #include <curses.h>
  29.  
  30. #if defined(XCURSES)
  31.     char *XCursesProgramName = "newdemo";
  32. #endif
  33.  
  34. #ifdef PDCDEBUG
  35. char *rcsid_newdemo  = "$Id$";
  36. #endif
  37.  
  38. /*
  39.  *  The Australian map
  40.  */
  41. char    *AusMap[16] =
  42. {
  43.     "           A           A ",
  44.     "    N.T. AAAAA       AAAA ",
  45.     "     AAAAAAAAAAA  AAAAAAAA ",
  46.     "   AAAAAAAAAAAAAAAAAAAAAAAAA Qld.",
  47.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ",
  48.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ",
  49.     " AAAAAAAAAAAAAAAAAAAAAAAAAAAA ",
  50.     "   AAAAAAAAAAAAAAAAAAAAAAAAA N.S.W.",
  51.     "W.A. AAAAAAAAA      AAAAAA Vic.",
  52.     "       AAA   S.A.     AA",
  53.     "                       A  Tas.",
  54.     ""
  55. };
  56.  
  57. /*
  58.  *  Funny messages
  59.  */
  60. #define NMESSAGES   6
  61.  
  62. char    *messages[] =
  63. {
  64.     "Hello from the Land Down Under",
  65.     "The Land of crocs. and a big Red Rock",
  66.     "Where the sunflower runs along the highways",
  67.     "the dusty red roads lead one to loneliness",
  68.     "Blue sky in the morning and",
  69.     "freezing nights and twinkling stars",
  70.     ""
  71. };
  72.  
  73. /*
  74.  *  Main driver
  75.  */
  76. main()
  77. {
  78. WINDOW  *win;
  79. int     w, x, y, i, j, len;
  80. time_t  t;
  81. char    buffer[80], *message;
  82. int     width, height;
  83. chtype  save[80], ch;
  84. void    trap();
  85.  
  86.     initscr();
  87.     start_color();
  88.     cbreak();
  89.     signal(SIGINT, trap);
  90.     noecho();
  91.  
  92. /*  refresh stdscr so that reading from it will not cause it to overwrite */
  93. /*  the other windows that are being created */
  94.  
  95.     refresh();
  96.  
  97.     width  = 48;
  98.     height = 14;                /* Create a drawing window */
  99.     win = newwin(height, width, (LINES-height)/2, (COLS-width)/2);
  100.     if(win == NULL)
  101.     {   endwin();
  102.         return 1;
  103.     }
  104.  
  105.     while(TRUE)
  106.     {   init_pair(1,COLOR_WHITE,COLOR_BLUE);
  107. /*        wattrset(win, COLOR_PAIR(1));*/
  108.         wbkgd(win, COLOR_PAIR(1));
  109.         werase(win);
  110.  
  111.         init_pair(2,COLOR_RED,COLOR_RED);
  112.         wattrset(win, COLOR_PAIR(2));
  113.         ch = ' ';
  114.         box(win, ch, ch);
  115.         wrefresh(win);
  116.         wattrset(win, 0);
  117.                                 /* Do ramdom output of a character */
  118.         ch = 'a';
  119.         nodelay(stdscr,TRUE);
  120.         for(i=0; i < 5000; ++i)
  121.         {   x = rand() % (width-2)  + 1;
  122.             y = rand() % (height-2) + 1;
  123.             mvwaddch(win, y, x, ch);
  124.             wrefresh(win);
  125.             if (getch() != ERR)
  126.                 break;
  127.             if(i == 2000)
  128.             {   ch = 'b';
  129.                 init_pair(3,COLOR_CYAN,COLOR_YELLOW);
  130.                 wattron(win, COLOR_PAIR(3));
  131.             }
  132.         }
  133.         nodelay(stdscr,FALSE);
  134.  
  135.         SubWinTest(win);
  136.                                 /* Erase and draw green window */
  137.         init_pair(4,COLOR_YELLOW,COLOR_GREEN);
  138. /*        wattrset(win, COLOR_PAIR(4) | A_BOLD);*/
  139.         wbkgd(win, COLOR_PAIR(4) );
  140.         wattrset(win, A_BOLD);
  141.         werase(win);
  142.         wrefresh(win);
  143.                                 /* Draw RED bounding box */
  144.         wattrset(win, COLOR_PAIR(2));
  145.         box(win, ' ', ' ');
  146.         wrefresh(win);
  147.                                 /* Display Australia map */
  148.         wattrset(win, A_BOLD);
  149.         i = 0;
  150.         while(*AusMap[i])
  151.     {   mvwaddstr(win, i+1, 8, AusMap[i]);
  152.             wrefresh(win);
  153.             napms(100);
  154.             ++i;
  155.         }
  156.  
  157.         init_pair(5,COLOR_BLUE,COLOR_WHITE);
  158.         wattrset(win, COLOR_PAIR(5) | A_BLINK);
  159.     mvwaddstr(win, height-2, 4, " PDCurses 2.2 for DOS, OS/2 and Xwindows");
  160.     wrefresh(win);
  161.  
  162.                 /* Draw running messages */
  163.     init_pair(6,COLOR_YELLOW,COLOR_WHITE);
  164.     wattrset(win, COLOR_PAIR(6));
  165.     message = messages[0];
  166.     len = strlen(message);
  167.     j = 0;
  168.     i = 2;
  169.     w = width-2;
  170.     nodelay(stdscr,TRUE);
  171.         while(j < NMESSAGES)
  172.         {   strncpy(buffer, message, w - i);
  173.             buffer[w-i] = 0;
  174.         mvwaddstr(win, height/2, i, buffer);
  175.             if(w - i < len)
  176.             {   memset(buffer, ' ', i);
  177.                 strcpy(buffer, message + (w - i));
  178.                 buffer[strlen(buffer)]   = ' ';
  179.                 buffer[i-2] = '\0';
  180.                 mvwaddstr(win, height/2, 2, buffer);
  181.         }
  182.             wrefresh(win);
  183.             if (getch() != ERR)
  184.             {   flushinp();
  185.         break;
  186.             }
  187.             mvwaddch(win, height/2, i, ' ');
  188.             i = ++i % w;
  189.             if(i < 2)
  190.             {   message = messages[++j%NMESSAGES];
  191.                 memset(buffer, ' ', w-2);
  192.         buffer[w-2] = 0;
  193.                 mvwaddstr(win, height/2, 2, buffer);
  194.                 i = 2;
  195.             }
  196.         napms(300);
  197.         }
  198.     nodelay(stdscr,FALSE);
  199.  
  200.         j = 0;
  201.                                 /*  Draw running As across in RED */
  202.         init_pair(7,COLOR_RED,COLOR_GREEN);
  203.         wattron(win, COLOR_PAIR(7));
  204.     for(i=2; i < width - 4; ++i)
  205.         {   ch = mvwinch(win, 4, i);
  206.             save[j++] = ch;
  207.             ch = ch & 0x7f;
  208.         mvwaddch(win, 4, i, ch);
  209.         }
  210.         wrefresh(win);
  211.  
  212.                                 /* Put a message up wait for a key */
  213.         i = height-2;
  214.         wattrset(win, COLOR_PAIR(5));
  215.     mvwaddstr(win, i, 5, " Type a key to continue or ESC to quit ");
  216.         wrefresh(win);
  217.  
  218.         if(WaitForUser() == '\033')
  219.         break;
  220.  
  221.         j = 0;                  /* Restore the old line */
  222.     wattrset(win,0);
  223.         for(i=2; i < width - 4; ++i)
  224.             mvwaddch(win, 4, i, save[j++]);
  225.         wrefresh(win);
  226.  
  227.     BouncingBalls(win);
  228.                                 /* Put a message up wait for a key */
  229.         i = height-2;
  230.         wattrset(win, COLOR_PAIR(5));
  231.     mvwaddstr(win, i, 5, " Type a key to continue or ESC to quit ");
  232.         wrefresh(win);
  233.         if(WaitForUser() == '\033')
  234.             break;
  235.     }
  236. exit:
  237.     endwin();
  238.     return 0;
  239. }
  240.  
  241. /*
  242.  * Test sub windows
  243.  */
  244. SubWinTest(WINDOW *win)
  245. {
  246. int     w, h, sw, sh, bx, by;
  247. WINDOW  *swin1, *swin2, *swin3;
  248.  
  249.     wattrset(win, 0);
  250.     w  = win->_maxx;
  251.     h  = win->_maxy;
  252.     bx = win->_begx;
  253.     by = win->_begy;
  254.     sw = w / 3;
  255.     sh = h / 3;
  256.     if((swin1 = derwin(win, sh, sw, 3, 5)) == NULL)
  257.         return  1;
  258.     if((swin2 = subwin(win, sh, sw, by+4, bx+8)) == NULL)
  259.         return  1;
  260.     if((swin3 = subwin(win, sh, sw, by+5, bx+11)) == NULL)
  261.     return  1;
  262.  
  263.     init_pair(8,COLOR_RED,COLOR_BLUE);
  264. /*    wattrset(swin1, COLOR_PAIR(8));*/
  265.     wbkgd(swin1, COLOR_PAIR(8));
  266.     werase(swin1);
  267.     mvwaddstr(swin1, 0, 3, "Sub-window 1");
  268.     wrefresh(swin1);
  269.  
  270.     init_pair(9,COLOR_CYAN,COLOR_MAGENTA);
  271. /*    wattrset(swin2, COLOR_PAIR(9));*/
  272.     wbkgd(swin2, COLOR_PAIR(9));
  273.     werase(swin2);
  274.     mvwaddstr(swin2, 0, 3, "Sub-window 2");
  275.     wrefresh(swin2);
  276.  
  277.     init_pair(10,COLOR_YELLOW,COLOR_GREEN);
  278. /*    wattrset(swin3, COLOR_PAIR(10));*/
  279.     wbkgd(swin3, COLOR_PAIR(10));
  280.     werase(swin3);
  281.     mvwaddstr(swin3, 0, 3, "Sub-window 3");
  282.     wrefresh(swin3);
  283.  
  284.     delwin(swin1);
  285.     delwin(swin2);
  286.     delwin(swin3);
  287.     WaitForUser();
  288.     return  0;
  289. }
  290.  
  291. /*
  292.  *  Bouncing balls
  293.  */
  294. BouncingBalls(WINDOW *win)
  295. {
  296. chtype     c1, c2, c3;
  297. int    w, h;
  298. int     x1, y1, xd1, yd1;
  299. int     x2, y2, xd2, yd2;
  300. int     x3, y3, xd3, yd3;
  301.  
  302.     wbkgd( win, COLOR_PAIR(1) );
  303.     wrefresh(win);
  304.  
  305.     w    = win->_maxx;
  306.     h    = win->_maxy;
  307.     x1   = 2 + rand() % (w - 4);
  308.     y1   = 2 + rand() % (h - 4);
  309.     x2   = 2 + rand() % (w - 4);
  310.     y2   = 2 + rand() % (h - 4);
  311.     x3   = 2 + rand() % (w - 4);
  312.     y3   = 2 + rand() % (h - 4);
  313.     xd1  = 1; yd1 = 1;
  314.     xd2  = 1; yd2 = 0;
  315.     xd3  = 0; yd3 = 1;
  316.     nodelay(stdscr,TRUE);
  317.     while(getch() == ERR)
  318.     {   x1 = xd1 > 0 ? ++x1 : --x1;
  319.         if(x1 <= 1 || x1 >= w - 2)
  320.             xd1 = xd1 ? 0 : 1;
  321.         y1 = yd1 > 0 ? ++y1 : --y1;
  322.         if(y1 <= 1 || y1 >= h - 2)
  323.         yd1 = yd1 ? 0 : 1;
  324.  
  325.         x2 = xd2 > 0 ? ++x2 : --x2;
  326.         if(x2 <= 1 || x2 >= w - 2)
  327.             xd2 = xd2 ? 0 : 1;
  328.         y2 = yd2 > 0 ? ++y2 : --y2;
  329.         if(y2 <= 1 || y2 >= h - 2)
  330.             yd2 = yd2 ? 0 : 1;
  331.  
  332.         x3 = xd3 > 0 ? ++x3 : --x3;
  333.         if(x3 <= 1 || x3 >= w - 2)
  334.         xd3 = xd3 ? 0 : 1;
  335.         y3 = yd3 > 0 ? ++y3 : --y3;
  336.         if(y3 <= 1 || y3 >= h - 2)
  337.             yd3 = yd3 ? 0 : 1;
  338.  
  339.         c1 = mvwinch(win, y1, x1);
  340.         c2 = mvwinch(win, y2, x2);
  341.         c3 = mvwinch(win, y3, x3);
  342.  
  343.         init_pair(8,COLOR_RED,COLOR_GREEN);
  344.         wattrset(win, COLOR_PAIR(8));
  345.     mvwaddch(win, y1, x1, 'O');
  346.         init_pair(9,COLOR_BLUE,COLOR_RED);
  347.         wattrset(win, COLOR_PAIR(9));
  348.         mvwaddch(win, y2, x2, '*');
  349.         init_pair(10,COLOR_YELLOW,COLOR_WHITE);
  350.         wattrset(win, COLOR_PAIR(10));
  351.         mvwaddch(win, y3, x3, '@');
  352.         wmove(win, 0, 0);
  353.         wrefresh(win);
  354.         wattrset(win,0);
  355.     mvwaddch(win, y1, x1, c1);
  356.     mvwaddch(win, y2, x2, c2);
  357.     mvwaddch(win, y3, x3, c3);
  358.     napms(150);
  359.     }
  360.     nodelay(stdscr,FALSE);
  361.     return 0;
  362. }
  363.  
  364. /*
  365.  *  Wait for user
  366.  */
  367. int WaitForUser()
  368. {
  369.  time_t  t;
  370.  chtype ch;
  371.  
  372.     nodelay(stdscr,TRUE);
  373.     t = time((time_t *)0);
  374.     while(1)
  375.       {   
  376.        if ((ch = getch()) != ERR)
  377.          {   
  378.           if (ch == '\033') 
  379.             {
  380.              nodelay(stdscr, FALSE);
  381.              return  ch;
  382.             }
  383.           else 
  384.             {
  385.              nodelay(stdscr, FALSE);
  386.              return  0;
  387.             }
  388.          }
  389.        if (time((time_t *)0) - t > 5) 
  390.          {
  391.           nodelay(stdscr, FALSE);
  392.           return  0;
  393.          }
  394.       }
  395. }
  396.  
  397. /*
  398.  *  Trap interrupt
  399.  */
  400. void trap()
  401. {
  402.     endwin();
  403.     exit(0);
  404. }
  405.  
  406. /*  End of NEWDEMO.C */
  407.